﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//class A
//{
//
//public:
//	void pirnt()
//	{
//		cout << _ch << endl;
//	}
//
//private:
//	char _ch;
//	int _i;
//};
//
//class B
//{
//
//public:
//	void pirnt()
//	{
////		cout << _ch << endl;
//	}
//
//
//private:
//	char _ch;
//	int _i;
//};
//class C
//{
//public:
//	void print()
//	{
//		//...
//	}
//};

//class C
//{
//};
//
//int main()
//{
////	cout << sizeof(A) << endl;
////	cout << sizeof(B) << endl;
////	cout << sizeof(C) << endl;
//
//	// 没有成员变量的类对象，分配1byte纯粹为了占位，表示对象存在
//	//B b1;
//	//B b2;
//	//cout << &b1 << endl;
//	//cout << &b2 << endl;
//	Date d1;
//	Date d2;
//	d1.Init(2024, 12, 1);
//	d2.Init(2025, 11, 2);
//
//	//// 这两个_year需要不同空间存储独立的值
//	//d1._year++;
//	//d2._year++;
//	//// Print函数指针是一样的，不需要独立的空间
//	d1.print();
//	d2.print();
//	cout << sizeof(Date) << endl;
//	cout << sizeof(d1) << endl;
//    return 0;
//}


//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = year;
//		_day = day;
//	}
//
//	void print()
//	{
//		cout << this << endl;
//		//this == nullptr;
//		cout << this->_year << "/"  << this->_month<< "/"  << this->_day << endl;
//	}
//
//		//void Print(Date* const this)
//		//{
//		//	cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
//		//}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	Date d2;
//	cout << &d1 << endl;
//	cout << &d2 << endl;
//	d1.Init(2024, 12, 1);
//	d2.Init(2024, 12, 2);
//	d1.print();
//	d2.print();
//	//d1.print(&d1);
//	//d2.print(&d2);
//	return 0;
//}

//class A
//{
//public:
//	void print()
//	{
//		cout << this << endl;
//		cout << "a::print()" << endl;
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};

//int main()
//{
//	A aa;
//	A* p = &aa;
//	p->print();
//	//call print 地址；
//	return 0;
//}

//class A
//{
//public:
//	void print()
//	{
//		cout << this << endl;
//		cout << "a::print()" << endl;
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};

//int main()
//{
//	A* p = nullptr;
//	(*p).Print(); // call Print地址
//	p->Print();
//
//	return 0;
//}

//int main()
//{
//	Stack st1;
//	st1.Init();
//	st1.Push(1);
//	st1.Push(2);
//	st1.Push(3);
//
//	cout << st1.Top() << endl;
//	st1.Pop();
//
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//
//	//cout << STTop(&s) << endl;
//	//STPop(&s);
//	cout << s.a[s.top-1] << endl;
//	--s.top;
//
//	return 0;
//}

//class Date
//{
//public:
//	/*void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << this->_year << "/" << this->_month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	// 函数声明
//	// Date func();
//
//	// 对象实例化一定会调用对应的构造，保证了对象实例化出来一定被初始化了
//	Date d1;
//	d1.Print();
//
//	Date d2(2025, 4, 22);
//	d2.Print();
//
//	return 0;
//}

//class Date
//{
//public:
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//
//	Date(int year,int month,int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//int main()
//{
//	Date d1(2025, 12, 1);
//	d1.print();
//	Date d2;
//	d2.print();
//	return 0;
//}
//class Date
//{
//public:
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};


//class Date
//{
//public:
//
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//
//	void print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main()
//{
//	Date d1;
//	d1.print();
//	Date d2(2025, 4, 30);
//	d2.print();
//	return 0;
//}
class Date
{
public:
	// 不写构造，编译生成默认构造
	//Date()
	//{
	//	_year = 1;
	//	_month = 1;
	//	_day = 1;
	//}
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << this->_year << "/" << this->_month << "/" << _day << endl;
	}

private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};

typedef int STDataType;
class stack
{
public:
	stack(int n = 4)
	{
		cout << "stack(int n ) == 4" << endl;
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;

	}
	~stack()
	{
		cout << "~stack()" << endl;
		free(_a);
		_a == nullptr;
		_capacity = _top = 0;
	}


private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

class MYqueue
{

private:
	//自定义类型
	stack _pushst;
	stack _popst;
};

int main()
{
	Date d1;
	d1.Print();
	//Date d2(2025);
    //d2.Print();

    //Date d3(2025, 12);
    //d3.Print();

    //Date d4(2025, 12, 23);
    //d4.Print();
	MYqueue q;

	stack st;

	return 0;
}


//typedef char STDataType;
//
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//
//// 初始化和销毁
//void STInit(ST* pst);
//void STDestroy(ST* pst);
//
//// 入栈  出栈
//void STPush(ST* pst, STDataType x);
//void STPop(ST* pst);
//
//// 取栈顶数据
//STDataType STTop(ST* pst);
//
//// 判空
//bool STEmpty(ST* pst);
//// 获取数据个数
//int STSize(ST* pst);
//
//// 初始化和销毁
//void STInit(ST* pst)
//{
//	assert(pst);
//
//	pst->a = NULL;
//	// top指向栈顶数据的下一个位置
//	pst->top = 0;
//
//	// top指向栈顶数据
//	//pst->top = -1;
//
//	pst->capacity = 0;
//}
//
//void STDestroy(ST* pst)
//{
//	assert(pst);
//
//	free(pst->a);
//	pst->a = NULL;
//	pst->top = pst->capacity = 0;
//}
//
//// 入栈  出栈
//void STPush(ST* pst, STDataType x)
//{
//	assert(pst);
//
//	// 扩容
//	if (pst->top == pst->capacity)
//	{
//		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//
//		pst->a = tmp;
//		pst->capacity = newcapacity;
//	}
//
//	pst->a[pst->top] = x;
//	pst->top++;
//}
//
//void STPop(ST* pst)
//{
//	assert(pst);
//	assert(pst->top > 0);
//
//	pst->top--;
//}
//
//// 20:08继续
//// 取栈顶数据
//STDataType STTop(ST* pst)
//{
//	assert(pst);
//	assert(pst->top > 0);
//
//	return pst->a[pst->top - 1];
//}
//
//// 判空
//bool STEmpty(ST* pst)
//{
//	assert(pst);
//
//	return pst->top == 0;
//}
//
//// 获取数据个数
//int STSize(ST* pst)
//{
//	assert(pst);
//
//	return pst->top;
//}
//
//bool isValid(char* s) {
//	ST st;
//	STInit(&st);
//	while (*s)
//	{
//		// 左括号入栈
//		if (*s == '(' || *s == '[' || *s == '{')
//		{
//			STPush(&st, *s);
//		}
//		else // 右括号取栈顶左括号尝试匹配
//		{
//			if (STEmpty(&st))
//			{
//				STDestroy(&st);
//				return false;
//			}
//
//			char top = STTop(&st);
//			STPop(&st);
//
//			// 不匹配
//			if ((top == '(' && *s != ')')
//				|| (top == '{' && *s != '}')
//				|| (top == '[' && *s != ']'))
//			{
//				STDestroy(&st);
//				return false;
//			}
//		}
//
//		++s;
//	}
//
//	// 栈不为空，说明左括号比右括号多，数量不匹配
//	bool ret = STEmpty(&st);
//	STDestroy(&st);
//
//	return ret;
//}


//#include<iostream>
//#include<assert.h>
//using namespace std;
//class Stack
//{
//public:
//	// 成员函数
//	void Init(int n = 4)
//	{
//		array = (int*)malloc(sizeof(int) * n);
//		if (nullptr == array)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		capacity = n;
//		top = 0;
//	}
//	void Push(int x)
//	{
//		// ...扩容
//		array[top++] = x;
//	}
//	int Top()
//	{
//		assert(top > 0);
//		return array[top - 1];
//	}
//	void Destroy()
//	{
//		free(array);
//		array = nullptr;
//		top = capacity = 0;
//	}
//private:
//	// 成员变量
//	int* array;
//	size_t capacity;
//	size_t top;
//}; // 分号不能省略
//int main()
//{
//	Stack st;
//	st.Init();
//	st.Push(1);
//	st.Push(2);
//	cout << st.Top() << endl;
//	st.Destroy();
//	return 0;
//}
//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	// 为了区分成员变量，⼀般习惯上成员变量
//	// 会加⼀个特殊标识，如_ 或者 m开头
//	int _year; // year_ m_year
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d;
//	d.Init(2024, 3, 31);
//	return 0;
//}

//#include<iostream>
//using namespace std;
//// C++升级struct升级成了类
//// 1、类⾥⾯可以定义函数
//// 2、struct名称就可以代表类型
//// C++兼容C中struct的⽤法
//typedef struct ListNodeC
//{
//	struct ListNodeC* next;
//	int val;
//}LTNode;
//// 不再需要typedef，ListNodeCPP就可以代表类型
//struct ListNodeCPP
//{
//	void Init(int x)
//	{
//		next = nullptr;
//		val = x;
//	}
//	ListNodeCPP* next;
//	int val;
//};
//
//int main()
//{
//	return 0;
//}
//#include<iostream>
//using namespace std;
//class Stack
//{
//public:
//	// 成员函数
//	void Init(int n = 4);
//private:
//	// 成员变量
//	int* array;
//	size_t capacity;
//	size_t top;
//};
//// 声明和定义分离，需要指定类域
//void Stack::Init(int n)
//{
//	array = (int*)malloc(sizeof(int) * n);
//	if (nullptr == array)
//	{
//		perror("malloc申请空间失败");
//		return;
//	}
//	capacity = n;
//	top = 0;
//}
//int main()
//{
//	Stack st;
//	st.Init();
//	return 0;
//}
//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	// 这⾥只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	// Date类实例化出对象d1和d2
//	Date d1;
//	Date d2;
//	d1.Init(2024, 3, 31);
//	d1.Print();
//	d2.Init(2024, 7, 5);
//	d2.Print();
//	return 0;
//}
//#include<iostream>
//using namespace std;
//// 计算⼀下A/B/C实例化的对象是多⼤？
//class A
//{
//public:
//	void Print()
//	{
//		cout << _ch << endl;
//	}
//private:
//	char _ch;
//	int _i;
//};
//class B
//{
//public:
//	void Print()
//	{
//		//...
//	}
//};
//class C
//{
//};
//int main()
//{
//	A a;
//	B b;
//	C c;
//	cout << sizeof(a) << endl; 
//	cout << sizeof(b) << endl;
//	cout << sizeof(c) << endl;
//	return 0;
//}

//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	// void Init(Date* const this, int year, int month, int day)
//	void Init(int year, int month, int day)
//	{
//		// 编译报错：error C2106: “=”: 左操作数必须为左值
//		// this = nullptr;
//		// this->_year = year;
//		_year = year;
//		this->_month = month;
//		this->_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	// 这⾥只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	// Date类实例化出对象d1和d2
//	Date d1;
//	Date d2;
//	// d1.Init(&d1, 2024, 3, 31);
//	d1.Init(2024, 3, 31);
//	d1.Print();
//	d2.Init(2024, 7, 5);
//	d2.Print();
//	return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//#include<stdbool.h>
//#include<assert.h>
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST* ps)
//{
//	assert(ps);
//	ps->a = NULL;
//	ps->top = 0;
//	ps->capacity = 0;
//}
//void STDestroy(ST* ps)
//{
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//void STPush(ST* ps, STDataType x)
//{
//	assert(ps);// 满了， 扩容
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
//			sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//bool STEmpty(ST* ps)
//{
//	assert(ps);
//	return ps->top == 0;
//}
//void STPop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	ps->top--;
//}
//STDataType STTop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	return ps->a[ps->top - 1];
//}
//int STSize(ST* ps)
//{
//	assert(ps); return ps->top;
//}
//int main()
//{
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//	while (!STEmpty(&s))
//	{
//		printf("%d\n", STTop(&s));
//		STPop(&s);
//	}
//	STDestroy(&s);
//	return 0;
//}

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	// 成员函数
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	void Pop()
	{
		assert(_top > 0);
		--_top;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:// 成员变量
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();
	return 0;
}